home *** CD-ROM | disk | FTP | other *** search
# Source Generated with Decompyle++ # File: in.pyc (Python 2.4) import unittest from test import test_support from bisect import bisect_right, bisect_left, insort_left, insort_right, insort, bisect from UserList import UserList class TestBisect(unittest.TestCase): precomputedCases = [ (bisect_right, [], 1, 0), (bisect_right, [ 1], 0, 0), (bisect_right, [ 1], 1, 1), (bisect_right, [ 1], 2, 1), (bisect_right, [ 1, 1], 0, 0), (bisect_right, [ 1, 1], 1, 2), (bisect_right, [ 1, 1], 2, 2), (bisect_right, [ 1, 1, 1], 0, 0), (bisect_right, [ 1, 1, 1], 1, 3), (bisect_right, [ 1, 1, 1], 2, 3), (bisect_right, [ 1, 1, 1, 1], 0, 0), (bisect_right, [ 1, 1, 1, 1], 1, 4), (bisect_right, [ 1, 1, 1, 1], 2, 4), (bisect_right, [ 1, 2], 0, 0), (bisect_right, [ 1, 2], 1, 1), (bisect_right, [ 1, 2], 1.5, 1), (bisect_right, [ 1, 2], 2, 2), (bisect_right, [ 1, 2], 3, 2), (bisect_right, [ 1, 1, 2, 2], 0, 0), (bisect_right, [ 1, 1, 2, 2], 1, 2), (bisect_right, [ 1, 1, 2, 2], 1.5, 2), (bisect_right, [ 1, 1, 2, 2], 2, 4), (bisect_right, [ 1, 1, 2, 2], 3, 4), (bisect_right, [ 1, 2, 3], 0, 0), (bisect_right, [ 1, 2, 3], 1, 1), (bisect_right, [ 1, 2, 3], 1.5, 1), (bisect_right, [ 1, 2, 3], 2, 2), (bisect_right, [ 1, 2, 3], 2.5, 2), (bisect_right, [ 1, 2, 3], 3, 3), (bisect_right, [ 1, 2, 3], 4, 3), (bisect_right, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0), (bisect_right, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 1), (bisect_right, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1), (bisect_right, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 3), (bisect_right, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3), (bisect_right, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 6), (bisect_right, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6), (bisect_right, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 10), (bisect_right, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10), (bisect_left, [], 1, 0), (bisect_left, [ 1], 0, 0), (bisect_left, [ 1], 1, 0), (bisect_left, [ 1], 2, 1), (bisect_left, [ 1, 1], 0, 0), (bisect_left, [ 1, 1], 1, 0), (bisect_left, [ 1, 1], 2, 2), (bisect_left, [ 1, 1, 1], 0, 0), (bisect_left, [ 1, 1, 1], 1, 0), (bisect_left, [ 1, 1, 1], 2, 3), (bisect_left, [ 1, 1, 1, 1], 0, 0), (bisect_left, [ 1, 1, 1, 1], 1, 0), (bisect_left, [ 1, 1, 1, 1], 2, 4), (bisect_left, [ 1, 2], 0, 0), (bisect_left, [ 1, 2], 1, 0), (bisect_left, [ 1, 2], 1.5, 1), (bisect_left, [ 1, 2], 2, 1), (bisect_left, [ 1, 2], 3, 2), (bisect_left, [ 1, 1, 2, 2], 0, 0), (bisect_left, [ 1, 1, 2, 2], 1, 0), (bisect_left, [ 1, 1, 2, 2], 1.5, 2), (bisect_left, [ 1, 1, 2, 2], 2, 2), (bisect_left, [ 1, 1, 2, 2], 3, 4), (bisect_left, [ 1, 2, 3], 0, 0), (bisect_left, [ 1, 2, 3], 1, 0), (bisect_left, [ 1, 2, 3], 1.5, 1), (bisect_left, [ 1, 2, 3], 2, 1), (bisect_left, [ 1, 2, 3], 2.5, 2), (bisect_left, [ 1, 2, 3], 3, 2), (bisect_left, [ 1, 2, 3], 4, 3), (bisect_left, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0), (bisect_left, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 0), (bisect_left, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1), (bisect_left, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 1), (bisect_left, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3), (bisect_left, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 3), (bisect_left, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6), (bisect_left, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 6), (bisect_left, [ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10)] def test_precomputed(self): for func, data, elem, expected in self.precomputedCases: self.assertEqual(func(data, elem), expected) self.assertEqual(func(UserList(data), elem), expected) def test_random(self, n = 25): randrange = randrange import random for i in xrange(n): data = [ randrange(0, n, 2) for j in xrange(i) ] data.sort() elem = randrange(-1, n + 1) ip = bisect_left(data, elem) if ip > 0: self.failUnless(data[ip - 1] < elem) ip = bisect_right(data, elem) if ip < len(data): self.failUnless(elem < data[ip]) if ip > 0: self.failUnless(data[ip - 1] <= elem) continue def test_optionalSlicing(self): for func, data, elem, expected in self.precomputedCases: for lo in xrange(4): lo = min(len(data), lo) for hi in xrange(3, 8): hi = min(len(data), hi) ip = func(data, elem, lo, hi) None(self.failUnless if ip <= ip else ip <= hi) if func is bisect_left and ip < hi: self.failUnless(elem <= data[ip]) if func is bisect_left and ip > lo: self.failUnless(data[ip - 1] < elem) if func is bisect_right and ip < hi: self.failUnless(elem < data[ip]) if func is bisect_right and ip > lo: self.failUnless(data[ip - 1] <= elem) self.assertEqual(ip, max(lo, min(hi, expected))) def test_backcompatibility(self): self.assertEqual(bisect, bisect_right) class TestInsort(unittest.TestCase): def test_vsBuiltinSort(self, n = 500): choice = choice import random for insorted in (list(), UserList()): for i in xrange(n): digit = choice('0123456789') if digit in '02468': f = insort_left else: f = insort_right f(insorted, digit) self.assertEqual(sorted(insorted), insorted) def test_backcompatibility(self): self.assertEqual(insort, insort_right) class LenOnly: '''Dummy sequence class defining __len__ but not __getitem__.''' def __len__(self): return 10 class GetOnly: '''Dummy sequence class defining __getitem__ but not __len__.''' def __getitem__(self, ndx): return 10 class CmpErr: '''Dummy element that always raises an error during comparison''' def __cmp__(self, other): raise ZeroDivisionError class TestErrorHandling(unittest.TestCase): def test_non_sequence(self): for f in (bisect_left, bisect_right, insort_left, insort_right): self.assertRaises(TypeError, f, 10, 10) def test_len_only(self): for f in (bisect_left, bisect_right, insort_left, insort_right): self.assertRaises(AttributeError, f, LenOnly(), 10) def test_get_only(self): for f in (bisect_left, bisect_right, insort_left, insort_right): self.assertRaises(AttributeError, f, GetOnly(), 10) def test_cmp_err(self): seq = [ CmpErr(), CmpErr(), CmpErr()] for f in (bisect_left, bisect_right, insort_left, insort_right): self.assertRaises(ZeroDivisionError, f, seq, 10) def test_arg_parsing(self): for f in (bisect_left, bisect_right, insort_left, insort_right): self.assertRaises(TypeError, f, 10) libreftest = '\nExample from the Library Reference: Doc/lib/libbisect.tex\n\nThe bisect() function is generally useful for categorizing numeric data.\nThis example uses bisect() to look up a letter grade for an exam total\n(say) based on a set of ordered numeric breakpoints: 85 and up is an `A\',\n75..84 is a `B\', etc.\n\n >>> grades = "FEDCBA"\n >>> breakpoints = [30, 44, 66, 75, 85]\n >>> from bisect import bisect\n >>> def grade(total):\n ... return grades[bisect(breakpoints, total)]\n ...\n >>> grade(66)\n \'C\'\n >>> map(grade, [33, 99, 77, 44, 12, 88])\n [\'E\', \'A\', \'B\', \'D\', \'F\', \'A\']\n\n' __test__ = { 'libreftest': libreftest } def test_main(verbose = None): test_bisect = test_bisect import test BuiltinFunctionType = BuiltinFunctionType import types import sys test_classes = [ TestBisect, TestInsort] if isinstance(bisect_left, BuiltinFunctionType): test_classes.append(TestErrorHandling) test_support.run_unittest(*test_classes) test_support.run_doctest(test_bisect, verbose) if verbose and hasattr(sys, 'gettotalrefcount'): import gc counts = [ None] * 5 for i in xrange(len(counts)): test_support.run_unittest(*test_classes) gc.collect() counts[i] = sys.gettotalrefcount() print counts if __name__ == '__main__': test_main(verbose = True) 
(.txt)